home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / xlisp_21.zoo / winterp.doc < prev    next >
Internet Message Format  |  1990-02-28  |  15KB
  1. From sce!mitel!uunet!tut.cis.ohio-state.edu!ucbvax!hplabs!hplabsz!mayer Thu Jan 11 12:51:21 EST 1990
  2. Article: 2234 of comp.lang.lisp
  3. Path: cognos!sce!mitel!uunet!tut.cis.ohio-state.edu!ucbvax!hplabs!hplabsz!mayer
  4. From: mayer@hplabsz.HPL.HP.COM (Niels Mayer)
  5. Newsgroups: comp.lang.lisp
  6. Subject: Re: XLISP Object Method Selectors :new and :isnew.
  7. Message-ID: <4613@hplabsz.HPL.HP.COM>
  8. Date: 10 Jan 90 07:26:26 GMT
  9. References: <1511@dinl.mmc.UUCP>
  10. Reply-To: mayer@hplabs.hp.com (Niels Mayer)
  11. Organization: Hewlett-Packard Labs, Software Technology Lab, Palo Alto, CA.
  12. Lines: 308
  13. Summary:
  14. Expires:
  15. Sender:
  16. Followup-To:
  17.  
  18. In article <1511@dinl.mmc.UUCP> noren@dinl.UUCP (Charles Noren) writes:
  19. >It's been a while since I've been on the net.  I can no longer
  20. >access comp.lang.lisp.x from our site, I suppose it went away?
  21.  
  22. it's still there...
  23.  
  24. >I've just starting playing with XLISP v2.0, particularly the
  25. >object-oriented features of it.  I've created new classes with
  26. >instance and class variables, and I've used the :new selector
  27. >to do so and it works just fine.  However, I see the :isnew
  28. >selector in the documentation and I was wondering how that works
  29. >compared to :new.
  30.  
  31. When I first looked at XLISP, I too found the documentation on the
  32. object system to be a little terse. Everything becomes much clearer
  33. once you see some examples. 
  34.  
  35. I recently wrote up some documentation on XLISP's object system for
  36. use with WINTERP (an XLISP-based rapid prototyping environment for
  37. applications based on the OSF Motif widgets). The following excerpt
  38. from winterp/doc/winterp.doc may help (get winterp via anonymous ftp
  39. from expo.lcs.mit.edu:oldcontrib/winterp.tar.Z). In particular, your
  40. question about :ISNEW is answered in the "object initialization"
  41. section. 
  42.  
  43.             --------------------
  44.  
  45. * Introduction to XLISP objects and Widgets.
  46.  
  47. WINTERP uses XLISP's object system as its interface to the class hierarchy
  48. of widgets provided by Motif. Specifically, each Motif widget class is
  49. represented by one or more object classes in WINTERP.  In order to best
  50. understand the capabilities of WINTERP's Motif interface, a brief review of
  51. the XLISP object system is in order. You may also want to consult the XLISP
  52. documentation ./winterp/doc/xLisp.doc for a more precise definition of the
  53. object system.
  54.  
  55. XLISP Classes describe the type of a particular object by declaring a set
  56. of variables held in each object. These "instance variables" may only be
  57. accessed by "methods" that respond to "messages" sent to the object.
  58. Methods are defined for particular classes, and functionality of other
  59. classes may be incorporated into new classes via "inheritance". From
  60. XLISP, Motif widget classes look just like normal XLISP objects -- that
  61. means that you can easily extend the functionality of Motif widgets by
  62. adding your own methods to a particular widget class. You may also use
  63. inheritance to attach your own data structures to widgets. The result is
  64. that WINTERP provides a very clean way to interactively rapid-prototype an
  65. application, while also providing mechanisms for code structuring and reuse.
  66. The latter is necessary in evolving from prototype to a structured,
  67. maintainable, and customizable deliverable.
  68.  
  69.  
  70. ** Creating new objects.
  71.  
  72. Create a new instance of a class by sending the message :NEW to
  73. <a_class_instance>:
  74.  
  75.     (SEND <a_class_instance> :NEW <parameters>)
  76.  
  77. <a_class_instance> is in fact an instance of class CLASS. Class CLASS allows
  78. you to define new class instances by specifying the instance variables and
  79. parent class of a particular class.
  80.  
  81.  
  82. ** Declaring a class.
  83.  
  84. To declare a "base class" object, that is, an object with no parent object,
  85. just send message :NEW to the object <CLASS>
  86.  
  87.     (SEND CLASS :NEW '(<ivar0> ... <ivarN>)
  88.              ['(<cvar0> ... <cvarM>)])
  89.  
  90. '(<ivar0> ... (ivarN>) are a list of symbols. Each <ivar-i> names an
  91. instance variable of the class. '(<cvar0> ... <cvarM>)]) are an optional
  92. list of variables that are shared among all instances of that particular
  93. class.
  94.  
  95.  
  96. ** Defining methods.
  97.  
  98. When a "message" is sent to an object, XLISP searches for a "method" to
  99. answer the message. A method is a piece of Lisp code that is executed when
  100. a particular message is sent to an object. Within the code of a method, all
  101. object instance and class variables are accessible. Furthermore, the symbol
  102. 'self' is bound to the object the message was sent to.
  103.  
  104. Methods are defined by sending the message :ANSWER to <a_class_instance>:
  105.  
  106.     (SEND a_class_instance :ANSWER <:msg> <parameters> <code>)
  107.  
  108. where <:msg> is a keyword symbol (a symbol with a ':' prefix) representing
  109. the message; <parameters> are the arguments given along with the message.
  110. See the documentation on "lambda lists" in /winterp/doc/xLisp.doc p.12 for
  111. details.  <code> is a list of s-expressions which get evaluated in response
  112. to a message. The lexical environment that existed for the call to :ANSWER
  113. will be used for value and functional bindings during method evaluation.
  114.  
  115. If you need to remember what the syntax is, consider the memory-helper
  116.     "this class :ANSWERs to :MESSAGE..." == (send <cls> :ANSWER :MESSAGE ...)
  117.  
  118.  
  119. ** Inheritance
  120.  
  121. So far, the object system we just described supports *encapsulation*.
  122. Encapsulation is good programming practice because it helps localize and
  123. detangle complexity. Unfortunately, encapsulation runs counter to
  124. flexibility because making flexible use of an object may require that
  125. certain groups of instance variables be accessed by different layers of new
  126. functionality. Most often, one wants to *reuse* aspects of a particular
  127. class in creating code that specializes and alters the functionality of
  128. that class. A compromise between encapsulation and flexibility is found by
  129. using *inheritance* in an object system. Inheritance is used to allow a
  130.  *subclass* to specialize the functionality of it's *parent class* (aka,
  131. the *superclass*):
  132.  
  133.     (send Class :NEW '(<ivar0> ... <ivarN>)
  134.                          '(<cvar0> ... <cvarM>)
  135.              <superclass>)
  136.  
  137. (<ivar0> ... <ivarN>) is a list of new instance variables in the subclass;
  138. (<cvar0> ... <cvarN>) is a list of new class variables in the subclass;
  139. <superclass> is a class instance representing the parent from which
  140. the new subclass inherits variables and methods.
  141.  
  142. "Inheritance" is occurring because all the instance variables of all the
  143. parent classes of the new subclass become the variables of each subclass
  144. instance. Furthermore, all methods defined on a parent class may also be
  145. used on a subclass instance. Note that while a subclass' methods can access
  146. the variables defined on the parent classes, the reverse isn't true.
  147.  
  148.  
  149. ** Object initialization.
  150.  
  151. As mentioned earlier, new object instances are created by sending the
  152. message :NEW to a class object. Sending the message :NEW to a class
  153. automatically sends message :ISNEW to the newly created instance. By
  154. default :ISNEW on an instance is a no-op method defined on class 'Object',
  155. which is the implicit [(grand)*]parent of all instances. If you want to
  156. initialize the instance/class variables of a particular class, you must
  157. define an :ISNEW method on the class.  Any parameters originally sent to
  158. the :NEW method will be passed on to the :ISNEW method and may be used to
  159. initialize an object to outside-world parameters.
  160.  
  161.  
  162. ** Example of using OOP features of XLISP with Motif widgets:
  163.  
  164. As currently implemented, the Motif class xmListWidgetClass makes it a bit
  165. baroque to create browsers (hopefully this will change in Motif 1.1).  The
  166. problem is that a "browser" is a kind of application that lends itself to
  167. object oriented techniques that are not always straightforward to support
  168. in C. One often has a collection of 'things' that one wants to display in a
  169. 'list' and perform actions on the 'thing' corresponding to the visual
  170. selection of an element in the displayed list. xmListWidgetClass will
  171. display an arrray of XmStrings in a list. When one or more elements in the
  172. list are selected, XmStrings corresponding to the selected elements are
  173. returned. Since the XmStrings you put into the list widget are not the
  174. XmStrings you get out, you must call XmStringCompare on each element of the
  175. collection of 'things' to find out which ones are selected.  Presumably,
  176. you'